home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d20 / doorskl3.arc / DOORSKL5.C < prev    next >
C/C++ Source or Header  |  1992-01-15  |  9KB  |  265 lines
  1. #ifndef __TURBOC__
  2.     #include <memory.h>
  3. #else
  4.     #include <mem.h>
  5. #endif
  6. #include "doorskel.h"
  7.  
  8.  
  9.  /* This module contains CRC routines for implementing file transfer
  10.     protocols or hash tables.  Omit module if you don't need them. */
  11.  
  12.  /* Callable routines: */
  13.  
  14.  int _pascal calcrc (char *ptrr, int count, int likexmodem);    /* 16 bit */
  15.  
  16.  long _fastcall crc32blk (char *str,int blklen);                /* 32 bit */
  17.  long _fastcall crc32str(char *str);
  18.  
  19.  
  20.  
  21.  
  22. /* First 16 bit CRC's (calculated) */
  23.  
  24.  
  25. #ifndef __TURBOC__
  26.  
  27. #pragma optimize("eg",off)
  28.  
  29. int _pascal calcrc (char *ptrr, int count, int likexmodem) {
  30.  
  31.     /* This function calculates the CRC used by the XMODEM/CRC Protocol
  32.        The first argument is a pointer to the message block.
  33.        The second argument is the number of bytes in the message block.
  34.        The function returns an integer which contains the CRC.
  35.        The low order 16 bits are the coefficients of the CRC. */
  36.  
  37.    unsigned int crc;
  38.    char         temp;
  39.  
  40.  
  41.     crc = 0;
  42.     while(count--) {
  43.         temp = *ptrr;
  44.         _asm {
  45.                     MOV     DX,[crc]
  46.                     XOR     DH,BYTE PTR[temp] ;init X^16 term
  47.                     XOR     DL,DL
  48.                     MOV     CX,8
  49.             CRCUP1: SHL     DX,1
  50.                     JNC     CRCUP2
  51.                     XOR     DX,1021h          ;X^12 + X^5 + 1
  52.             CRCUP2: LOOP    CRCUP1
  53.                     XOR     DH,BYTE PTR[crc]  ;finish X^16 term
  54.                     MOV     [crc],DX          ;update CRC accumulator
  55.         }
  56.         ptrr++;
  57.     }
  58.  
  59.     if(likexmodem) {
  60.         _asm {                                ;swap bytes
  61.             MOV     DX,[crc]
  62.             XCHG    DH,DL
  63.             MOV     [crc],DX
  64.         }
  65.     }
  66.  
  67.     return crc;
  68. }
  69.  
  70.  #pragma optimize("eg",on)
  71.  
  72. #else
  73.  
  74. /*
  75.     This code will calculate a 16-bit CRC.  crc_update() returns an
  76.     updated CRC value given a current CRC value and a character.
  77.     crc_finish() must be called once after all characters in a block
  78.     have been processed for a message to be _transmitted_ and returns
  79.     the calculated CRC which should be transmitted as the final 2
  80.     bytes of the character block.
  81.  
  82.     e.g.    crc_value = 0;          // initialize CRC
  83.             crc_value = crc_update( crc_value, ch);
  84.             .
  85.             .
  86.             crc_value = crc_finish( crc_value);
  87.  
  88.     _bits will contain the character to be processed in bits 0-7 and
  89.     the CRC in bits 8-23.  Bit 24 is used to test for overflow.
  90.     The value generated is the CCITT-recommended CRC generator of
  91.     x^16 + x^12 + x^5 + 1.  To produce a standard IBM synchronous
  92.     transmission protocol CRC, use #define XOR 0x01800500l, giving
  93.     x^16 + x^15 + x^2 + 1.
  94. */
  95.  
  96. #define XOR 0x01102100l
  97.  
  98. int crc_update (int crc,char crc_char) {
  99.  
  100.     long bits;
  101.     short index;
  102.  
  103.     bits = ((long)crc << 8)+crc_char;
  104.     for(index = 0;index < 8;index++){
  105.         bits <<= 1;
  106.         if(bits & 0x01000000l) bits^=XOR;
  107.     }
  108.     return((int)((bits & 0x00ffff00l) >> 8));
  109. }
  110.  
  111.  
  112. int crc_finish (int crc){
  113.     return(crc_update(crc_update(crc,'\0'),'\0'));
  114. }
  115.  
  116.  
  117. int _pascal calcrc (char *ptrr, int count, int likexmodem) {
  118.  
  119.    unsigned int crc;
  120.    char temp;
  121.  
  122.  
  123.     crc = 0;
  124.     count++;
  125.     while(--count) {
  126.         temp = *ptrr;
  127.         crc = crc_update(crc,temp);
  128.         ptrr++;
  129.     }
  130.     crc = crc_finish(crc);
  131.  
  132.     if(likexmodem) swab((char *)&crc,(char *)&count,sizeof(int));
  133.     else return crc;
  134.     return count;
  135. }
  136.  
  137. #endif
  138.  
  139.  
  140.  
  141.  
  142. /* Now 32 bit CRC's table-driven */
  143.  
  144.  
  145.  long cr3tab[] = {                   /* CRC polynomial 0xEDB88320 */
  146.  
  147.    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
  148.    0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
  149.    0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
  150.    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
  151.    0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
  152.    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
  153.    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
  154.    0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
  155.    0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
  156.    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
  157.    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
  158.    0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
  159.    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
  160.    0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
  161.    0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
  162.    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
  163.    0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
  164.    0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
  165.    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
  166.    0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
  167.    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
  168.    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
  169.    0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
  170.    0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
  171.    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
  172.    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
  173.    0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
  174.    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
  175.    0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
  176.    0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
  177.    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
  178.    0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
  179.    0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
  180.    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
  181.    0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
  182.    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
  183.    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
  184.    0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
  185.    0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
  186.    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
  187.    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
  188.    0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
  189.    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
  190.    0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
  191.    0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
  192.    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
  193.    0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
  194.    0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
  195.    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
  196.    0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
  197.    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
  198.    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
  199.    0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
  200.    0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
  201.    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
  202.    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
  203.    0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
  204.    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
  205.    0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
  206.    0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
  207.    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
  208.    0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
  209.    0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
  210.    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
  211.  };
  212.  
  213.  
  214. /*-------------------------------------------------------------------------*/
  215. /* Calculate CRC-32 of variable length string                              */
  216. /*-------------------------------------------------------------------------*/
  217. /*                                                                         */
  218. /*  Usage: Passed pointer to ASCIIZ string to take CRC-32 of, as 'str'.    */
  219. /*                                                                         */
  220. /*   Rets: (long) CRC-32 value of passed string.                           */
  221. /*                                                                         */
  222. /*  Notes: The function treats the passed string as UPPER CASE so          */
  223. /*         it is insensitive to case.                                      */
  224. /*                                                                         */
  225. /*-------------------------------------------------------------------------*/
  226.  
  227. long _fastcall crc32str (char *str) {
  228.  
  229.    long crc = -1L;
  230.  
  231.  
  232.    while(*str) {
  233.       crc = cr3tab[((int)crc ^ toupper(*str)) & 0xff] ^ ((crc >> 8) & 0x00FFFFFF);
  234.       str++;
  235.    }
  236.  
  237.    return crc;
  238. }
  239.  
  240.  
  241.  
  242. /*-------------------------------------------------------------------------*/
  243. /* Calculate CRC-32 of memory block                                        */
  244. /*-------------------------------------------------------------------------*/
  245. /*                                                                         */
  246. /*  Usage: Passed pointer to memory block (cast to char *) as 'str' and    */
  247. /*         block length as int 'blklen'.                                   */
  248. /*                                                                         */
  249. /*   Rets: (long) CRC-32 value of passed block.                            */
  250. /*                                                                         */
  251. /*-------------------------------------------------------------------------*/
  252.  
  253. long _fastcall crc32blk (char *str,int blklen) {
  254.  
  255.    long crc = -1L;
  256.  
  257.  
  258.    while(blklen--) {
  259.       crc = cr3tab[((int)crc ^ *str) & 0xff] ^ ((crc >> 8) & 0x00FFFFFF);
  260.       str++;
  261.    }
  262.  
  263.    return crc;
  264. }
  265.